#ifndef _GAME_PUBSTRUCT_H
#define _GAME_PUBSTRUCT_H

#include "Resource.h"

enum SmallGameType
{
	en_SmallGame_Lottery = 1,		// 抽奖
};

typedef struct small_game_st
{
	uint8 id;
	uint8 type;
	uint8 status;
	uint16 model_id;
	uint32 num;
	uint32 data1;
	uint32 data2;
	std::vector<uint8> points;
	small_game_st(void)
	{
		initialize();
	}
	
	void initialize(void)
	{
		id = 0;
		type = 0;
		status = 0;
		model_id = 0;
		num = 0;
		data1 = 0;
		data2 = 0;
		points.clear();
	}
	
}SMGameData;

typedef struct small_game_cmd_st
{
	uint16 gameid;
	uint16 cmdid;
	uint32 buildtime;
	
	std::vector<uint32>	vcparam;
	std::vector<String>	vcstring;

	small_game_cmd_st(void)
	{
		initialize();
	}
	
	void initialize(void)
	{
		buildtime = 0;
		gameid = 0;
		cmdid = 0;
		vcparam.clear();
		vcstring.clear();		
	}
}SmallGameOrder;

typedef struct vip_room_st
{
	uint32 room_id;			//VIP房间ID
	uint32 landlord_id;		//房主ID
	uint32 base_coins;		//底注
	uint32 least_multiple;	//玩家最少携带铜钱的倍数（基于底注）
	uint8 status;			//房间状态（0 无效 1 等待 2 满员 4 游戏中）
	
	bool bHaveCodeKey;		//密码标志
	String strCode;			//游戏密码
	
	std::vector<ResourceProxy> normal_players;	//普通玩家列表
	std::vector<uint8> players_status;			//列表玩家状态（0 无效 1 等待 2 游戏中）
	
	vip_room_st(void)
	{
		initialize();
	}
	
	void initialize(void)
	{
		room_id = 0;
		landlord_id = 0;
		base_coins = 0;
		least_multiple = 0;
		status = 0;
		bHaveCodeKey = false;
		strCode = "";
		
		normal_players.clear();
		players_status.clear();
	}
	
}VipRoom;



// 物品数据
struct ItemData
{
	uint32 modelId;		// 脚本号
	uint32 num;		// 数量
	uint32 odds;	// 几率

	ItemData()
	{
		modelId = 0;
		num = 0;
		odds = 0;
	}
};
// 物品集
struct ItemSet
{
	uint32 base;	// 随机基数,如果为0，表示随机
	std::vector<ItemData> vecItem;
	
	ItemSet()
	{
		base = 0;
		vecItem.clear();
	}
};

// 弹幕信息
struct stDanMu
{
	uint32 danmu_id;	// 弹幕ID（角色ID）
	uint32 char_id;		// 发弹幕玩家ID
	uint32 pos;			// 位置信息（弹幕出现在屏幕的高度）
	uint32 isVip;		// 是否VIP弹幕
	
	String content;		// 弹幕内容
	String srcName;		// 发送
	
	stDanMu()
	{
		init();
	}
	
	void init()
	{
		danmu_id = 0;
		char_id = 0;
		pos = 0;
		isVip = 0;
		
		content = "";
		srcName = "";
	}
	
};

// 公共排行信息
struct stCommonQueueTop
{
	uint32 id; 	 		// id
	uint32 pid;	 		// pid
	String name; 		// 昵称
	String head; 		// 头像
	uint32 data;		// 排名数据
	uint8 trend; 		// 排行趋势（0：下降 1：持平 2：上升）暂时不使用
	String sign_name;	// 签名
	String addr;		// 地址
	uint8 sex;			// 性别
};

// 公共比赛结构
struct stPlayerMarchInfo
{
	ResourceProxy chrProxy;		// 参加比赛的玩家proxy
	uint32 status;				// 玩家比赛状态
	uint32 stage;				// 比赛阶段（预赛，决赛等）
	uint32 order;				// 比赛名次
	uint32 signup_order;		// 报名顺序（用于同分玩家排名谁靠前用）
	uint32 turn_count;			// 比赛轮次
	int score;					// 比赛积分
	
	stPlayerMarchInfo()
	{
		init();
	}
	
	void init()
	{
		chrProxy.setNull();
		status = 0;
		stage = 0;
		order = 0;
		signup_order = 0;
		turn_count = 0;
		score = 0;
	}
	
};

// 投票玩家数据
struct stVotePlayer
{
	uint32 char_id;		// 角色ID
	uint8 vote_status;	// 投票状态
	
	stVotePlayer()
	{
		Init();
	}
	
	void Init()
	{
		char_id = 0;
		vote_status = 0;
	}
};

//========================================麻将相关结构体=================================
// 杠牌
struct GangCard
{
	uint32 card; 			// 牌
	uint32 type;			// 杠牌类型
	
	GangCard()
	{
		Init();
	}
	
	void Init()
	{
		card = 0;
		type = 0;
	}
};

// 胡牌信息
struct HuInfo
{
	uint32 huCard;			// 可胡的牌
	uint32 huType;			// 胡牌类型
	uint32 power;			// 番数
	uint32 genNum;			// 根数量
	uint32 gangNum;			// 杠数量
	uint32 jiangCard;		// 将牌
	uint32 tackHuType;		// 胡牌可累计加番类型
	uint32 fangPaoPos;		// 放炮方
	uint32 huLucre;			// 胡牌收益
	
	HuInfo()
	{
		Init();
	}
	void Init()
	{
		huCard = 0;
		huType = 0;
		power = 0;
		genNum = 0;
		gangNum = 0;
		jiangCard = 0;
		tackHuType = 0;
		fangPaoPos = 0;
		huLucre = 0;
	}
};

// 收益
struct Lucre
{
	enum LucreType
	{
		en_Lucre_Hu = 1, 				// 胡
		en_Lucre_Gang = 2, 				// 杠
		en_Lucre_Jiao = 3, 				// 查叫
		en_Lucre_CancelGang = 4 		// 退杠
	};
	
	uint32 type;						// 收益操作
	uint32 optType;						// 操作类型
	uint32 data1;						// 附加数据(胡：附加番*10+根)
	uint32 data2;						// 附加数据(胡：胡牌收益的类型 (点炮，接炮，自摸，其他玩家自摸))
	uint32 data3;						// 附加数据(胡：累计加番类型 (抢杠胡,杠上炮,杠上花))
	bool   isZiMo;						// 是否自摸
	std::map<uint32, int32> mapLucre;	// 位置，收益
};


// 麻将牌信息
struct MJCards
{
	std::set<uint32> setKeZi; 							// 刻子
	std::vector<GangCard> vecGang;						// 杠
	std::map<uint32, std::vector<uint32> > mapCards;	// 手里其他牌
	std::vector<GangCard> vecCanGang; 					// 可杠的牌
	std::map<uint32, uint32> mapShunCards; 				// 连牌

	uint32 preAction;									// 对当前牌的可用操作
	uint32 que_color;									// 定缺花色
	uint32 standCount;									// 站着的数量
	uint32 shutCount;									// 倒下的数量

	std::set<uint32> setColor; 							// 花色（检测番型时用到）
	std::set<uint32> setAnKe;							// 独立存在的暗刻，根
	std::map<uint32, uint32> mapColorCount;				// 花色数量

	HuInfo hu;											// 胡牌信息

	////MJCards();
	//void Init();

	//bool checkcards(std::vector<uint16> cards);			// 检查牌列表是否存在	

	//													// 重置检查碰杠胡相关数据
	//void ResetChkData();
	//bool GetColorValueOfCard(const uint32 card, uint32 & color, uint32 & value);

	////打牌及操作牌相关函数
	//bool AddCard(const uint32 card);
	//bool CastCard(const uint32 card);
	//bool Peng(const uint32 card);
	//bool Gang(GangCard &gc, bool bWait = false);

	//// 统计花色
	//void CountColor();
	//// 检查是否花猪
	//bool IsColorPig();
	//// 检查手牌是否存在此列表
	//bool CheckHandCardsHasThese(std::vector<uint32> & vecCards);
	//// 自动出牌牌值
	//uint32 GetAutoCastCard();

};

typedef struct _st_mj_tableplayer
{
	ResourceProxy player;



	MJCards cards;						// 手上的牌
	GangCard gc; 						// 当前杠牌

	uint32 lastCard;					// 最后摸的牌
	uint32 getCount;					// 摸牌次数
	uint32 opt;							// 碰杠胡操作
	std::list<uint32> lstOutCards;		// 打出的牌
	std::list<Lucre> lstLucre;			// 收益列表
	std::list<HuInfo> lstHu;			// 胡牌列表
										//uint32 lastOpt;						// 前一次操作
										//uint32 lastPower; 					// 放弃胡牌的番数
	uint32 status;						// 游戏状态（正常、离线、托管）
	uint32 swapOpt;						// 换牌操作
	uint32 swapNum;						// 换牌数量
	int32 winLurce; 					// 每局收益
	std::vector<uint16> vecInitSwapingCards;	// 系统默认交换牌
	std::vector<uint16> vecSwapingCards;	// 等待交换牌列表
	std::vector<uint16> vecSwapedCards;		// 已交换牌列表
	uint8 ui8SwapFrom;						//换牌来源
	bool isSwap;						// 是否换牌
	bool isBanker;						// 是否庄家
	bool isDropHu; 						// 是否在本轮放弃过胡牌
	bool isLeave; 						// 是否离开
										//
	std::vector<uint32> swapedCards;	// 换牌
										//

	uint8 nAgreePlayerGame;				// 是否同意开始游戏
	uint32 pos;							// 玩家座位（255表示没入座）
	int32 score;						// 棋牌圈分数
	uint8 playerJoinState;				// 玩家加入游戏状态
	uint8 bFZ;							// 玩家是不是房主
	uint8 voteChoice;					// 投票选择
	uint8 goOn;							// 有相同IP时，选择是否继续游戏
	ResourceProxy playerProxy;			// 玩家信息(棋牌圈用于获取玩家信息)
										//
	uint8 ziMoNum;						//自摸次数
	uint8 jiePaoNum;					//接炮次数
	uint8 dianPaoNum;					//点炮次数
	uint8 qiangGangNum;					//抢杠次数
	uint8 anGangNum;					//暗杠次数
	uint8 mingGangNum;					//明杠次数
	uint8 buGangNum;					//补杠次数
	uint8 chajiaoNum;					//查叫次数
	uint8 gangshanghuaNum;					//查叫次数
										//
	_st_mj_tableplayer()
	{
		//	m_pMJBaseInterface = NULL;
		//	Init();
	}
	//
	/* // 玩家牌桌数据初始化
	void Init();
	// 重置检查碰杠胡相关数据
	void ResetChkData();
	// 获取最近一次杠牌
	uint32 GetLastGangLucre();
	// 添加收益
	Lucre & NewLucre(const uint32 type, const uint32 optType, const uint32 pos = 0, const int32 value = 0, const uint32 data1 = 0, const uint32 huLucreType = 0, const uint32 tackHuType = 0);
	// 追加收益方
	bool AddLucrePos(Lucre &lc, const uint32 pos, const int32 value);
	// 获取杠各方得钱
	void GetGangWin(std::map<uint32, uint32> &mapWin);
	// 获得杠牌收益
	void GetGangLucre();
	// 统计最终收益
	void CountTotalLucre();
	//重置玩家数据
	void ResetPlayerInfo(); */

	
}MJTablePlayer;

//========================================麻将相关结构体=================================

struct stIncomePlayerInfo
{
	uint32 pid;				// 玩家pid
	uint32 model_id;		// 收益道具模式ID
	uint32 num;				// 收益道具数量
	uint32 unShouYiNum;		// 不参与分成数量
	
	stIncomePlayerInfo()
	{
		Init();
	}
	
	void Init()
	{
		pid = 0;
		model_id = 0;
		num = 0;
		unShouYiNum = 0;
	}
};

struct stIncomeInfo
{
	uint32 game_id;								// 游戏ID
	uint32 gz_id;								// 分区ID
	uint32 cb_id;								// 组局ID
	uint32 agent_id;							// 代理商ID
	uint32 channel_id;							// 牌桌ID
	uint32 town_id;								// 房间ID
	uint32 loop_id;								// 轮次
	
	String join_code;							// 房间ID
	String end_time;							// 结束时间
	std::vector<stIncomePlayerInfo>	vPlayers;	// 用户信息
	
	stIncomeInfo()
	{
		Init();
	}
	
	void Init()
	{
		game_id = 0;
		gz_id = 0;
		cb_id = 0;
		agent_id = 0;
		channel_id = 0;
		town_id = 0;
		loop_id = 0;
		
		join_code = "";
		end_time = "";
		vPlayers.clear();
	}
};
 
struct stXxjjcPointsInfo
{
	uint32 pid;
	uint32 gz_id;
	uint32 game_id;
};

struct stGatewayExChangeInfo
{
	uint32 prizes_id;				// 礼品ID
	uint32 type;					// 10 实物 20 虚拟道具
	uint32 num;						// 可兑换次数(目前暂时不需要判断）
	uint32 prizes_model_id;			// 兑换后获得的道具模式ID
	uint32 prizes_model_num;		// 兑换后获得的道具数量
	uint32 exchange_limit;			// 单人兑换限制
	
	uint32 exchange_model_id;
	uint32 exchange_model_num;
	String exchange_model_name;
	String exchange_model_image;
	
	String name;								// 名称
	String desc;								// 描述
	String image;								// 图像
	
	String exchange_valid_time;					// "2018-07-29 14:00:00",	// 兑换开始时间
	String exchange_expire_time;				// "2018-08-10 14:00:00",	// 兑换结束时间
	String useful_valid_time; 					// 2018-07-10 14:00:00",	// 使用有效期开始时间
	String useful_expire_time; 					// 0000-00-00 00:00:00",	// 使用有效期结束时间
	uint32 useful_expire_relative_time; 		//	1296000 秒				// 购买后的有效时间
	
	stGatewayExChangeInfo()
	{
		Init();
	}
	
	void Init()
	{
		prizes_id = 0;
		prizes_model_id = 0;
		prizes_model_num = 0;
		type = 0;
		num = 0;
		exchange_limit = 0;
		
		exchange_model_id = 0;
		exchange_model_num = 0;
		exchange_model_name = "";
		exchange_model_image = "";
		
		name = "";
		desc = "";
		image = "";
		
		exchange_valid_time = "";
		exchange_expire_time = "";
		useful_valid_time = "";
		useful_expire_time = "";
		useful_expire_relative_time = 0;
		
	}
	
};

// 公共扑克牌类牌桌玩家结构体


#endif
